"""
提示词工程模块工厂
负责创建和管理提示词工程模块实例
支持自定义组件，允许用户扩展功能
"""

from typing import Dict, Any, Optional, List, Type
from src.research_core.prompt_eng_modules import (
    IPromptEngineeringModule,
    IPromptEngineeringModuleFactory,
    IRequirementAnalysisModule,
    IPromptDesignModule,
    IPromptEvaluationModule,
    IPromptOptimizationModule,
    IHummanFeedbackModule,
    BasePromptEngineeringModule
)
from src.research_core.prompt_eng_agents import (
    RequirementAnalysisModule,
    PromptDesignModule,
    PromptEvaluationModule,
    PromptOptimizationModule
)


class PromptEngineeringModuleFactory(IPromptEngineeringModuleFactory):
    """
    提示词工程模块工厂实现
    负责创建和管理提示词工程模块实例
    """
    
    def __init__(self):
        # 默认模块实现映射
        self._default_modules: Dict[str, Type[IPromptEngineeringModule]] = {
            "requirement_analysis": RequirementAnalysisModule,
            "prompt_design": PromptDesignModule,
            "prompt_evaluation": PromptEvaluationModule,
            "prompt_optimization": PromptOptimizationModule
        }
        
        # 注册的自定义模块实现
        self._custom_modules: Dict[str, Type[IPromptEngineeringModule]] = {}
        
        # 模块实例缓存
        self._module_instances: Dict[str, IPromptEngineeringModule] = {}
    
    def create_module(self, module_type: str, config: Optional[Dict[str, Any]] = None) -> IPromptEngineeringModule:
        """
        创建模块实例
        
        Args:
            module_type: 模块类型
            config: 配置信息（可选）
            
        Returns:
            模块实例
        """
        # 检查是否有缓存的实例
        instance_key = f"{module_type}_{hash(str(config))}"
        if instance_key in self._module_instances:
            return self._module_instances[instance_key]
        
        # 查找模块类
        module_class = self._get_module_class(module_type)
        if not module_class:
            raise ValueError(f"未知的模块类型: {module_type}")
        
        # 创建实例
        if config:
            instance = module_class(**config)
        else:
            instance = module_class()
        
        # 缓存实例
        self._module_instances[instance_key] = instance
        
        return instance
    
    def _get_module_class(self, module_type: str) -> Optional[Type[IPromptEngineeringModule]]:
        """
        获取模块类
        
        Args:
            module_type: 模块类型
            
        Returns:
            模块类或None
        """
        # 优先查找自定义模块
        if module_type in self._custom_modules:
            return self._custom_modules[module_type]
        
        # 查找默认模块
        if module_type in self._default_modules:
            return self._default_modules[module_type]
        
        return None
    
    def register_module(self, module_type: str, module_class: Type[IPromptEngineeringModule]):
        """
        注册模块实现类
        
        Args:
            module_type: 模块类型
            module_class: 模块实现类
        """
        # 验证模块类是否实现了正确的接口
        if not issubclass(module_class, IPromptEngineeringModule):
            raise ValueError("模块类必须实现IPromptEngineeringModule接口")
        
        self._custom_modules[module_type] = module_class
        
        # 清除相关缓存
        self._clear_cache_for_module(module_type)
    
    def unregister_module(self, module_type: str):
        """
        注销模块实现类
        
        Args:
            module_type: 模块类型
        """
        if module_type in self._custom_modules:
            del self._custom_modules[module_type]
            
            # 清除相关缓存
            self._clear_cache_for_module(module_type)
    
    def _clear_cache_for_module(self, module_type: str):
        """
        清除指定模块类型的缓存
        
        Args:
            module_type: 模块类型
        """
        keys_to_remove = [
            key for key in self._module_instances.keys() 
            if key.startswith(f"{module_type}_")
        ]
        for key in keys_to_remove:
            del self._module_instances[key]
    
    def get_available_modules(self) -> List[str]:
        """
        获取可用模块列表
        
        Returns:
            可用模块类型列表
        """
        all_modules = set()
        all_modules.update(self._default_modules.keys())
        all_modules.update(self._custom_modules.keys())
        return list(all_modules)
    
    def get_module_info(self) -> Dict[str, Dict[str, str]]:
        """
        获取模块信息
        
        Returns:
            模块信息字典
        """
        info = {}
        
        # 添加默认模块信息
        for module_type, module_class in self._default_modules.items():
            info[module_type] = {
                "type": "default",
                "class": module_class.__name__,
                "description": getattr(module_class, '__doc__', '无描述').split('\n')[0] if module_class.__doc__ else '无描述'
            }
        
        # 添加自定义模块信息
        for module_type, module_class in self._custom_modules.items():
            info[module_type] = {
                "type": "custom",
                "class": module_class.__name__,
                "description": getattr(module_class, '__doc__', '无描述').split('\n')[0] if module_class.__doc__ else '无描述'
            }
        
        return info


# 全局模块工厂实例
_module_factory = PromptEngineeringModuleFactory()


def get_module_factory() -> IPromptEngineeringModuleFactory:
    """
    获取全局模块工厂实例
    
    Returns:
        模块工厂实例
    """
    return _module_factory


def create_prompt_eng_module(module_type: str, config: Optional[Dict[str, Any]] = None) -> IPromptEngineeringModule:
    """
    创建提示词工程模块实例
    
    Args:
        module_type: 模块类型
        config: 配置信息（可选）
        
    Returns:
        模块实例
    """
    factory = get_module_factory()
    return factory.create_module(module_type, config)


# 导出类和函数
__all__ = [
    'PromptEngineeringModuleFactory',
    'get_module_factory',
    'create_prompt_eng_module'
]